interface P {
	setName(name: string): void;
}

class Person implements P {
	// 给类定义属性，只有类可以使用，实例对象不能使用
	static aaa: string = "aaa";
	// 给类定义方法，只有类可以使用，实例对象不能使用
	static say(text: string) {
		console.log(text);
	}

	// 给实例对象定义属性类型
	public name: string; // 公开的：都可以访问
	private readonly age: number; // 私有的：只能当前类可以访问(实例和子类都不能访问)
	// 给实例对象定义的属性
	protected sex: string = "男"; // 受保护的: 只有当前类和子类可以访问（实例不能访问）s

	constructor(name: string, age: number) {
		// 给实例对象定义的属性
		this.name = name;
		this.age = age;
	}

	// 给实例对象定义属性：phone
	// 当你读取phone属性触发get phone() {}
	// 当你设置phone属性触发set phone() {}
	get phone() {
		return "1300000000";
	}
	set phone(val: string) {
		console.log(val, this.age);
	}

	// 给原型对象定义的方法
	setName(name: string) {
		this.name = name;
	}
	// 给实例对象定义的方法
	setAge = (age: number) => {
		console.log(age);
	};
}
/*
  p: {
    name: xxx,
    age: xxx,
    sex: xxx,
    setAge() {},
    __proto__: {
      setName() {}
    }
  }
*/
const p = new Person("jack", 18);
console.log(p);

class Son extends Person {
	// 当使用extends的时候，使用constructor必须调用super
	// 当使用extends的时候，不使用constructor不调用super
	constructor(name: string, age: number) {
		super(name, age); // 调用父类constructor方法
		console.log(this.sex);
	}

	setName() {}
}

/*
  s: {
    name: xxx,
    age: xxx,
    sex: xxx,
    setAge() {},
    __proto__: { // Son.prototype
      setName() {}
      __proto__: { // Person.prototype
        setName() {}
      }
    }
  }
*/
const s = new Son("rose", 16);

// 抽象类
abstract class Animal {}
// 不能new调用
// new Animal()
// 只能被继承
class Cat extends Animal {}
